const getSearchValue = (searchValue) => {
    // 匹配汉字、英文字符、数字
    let pattern = /([\u4e00-\u9fa5]|[a-zA-Z0-9])+/g
    return searchValue.match(pattern)
}

/**
 * 采用JSON格式化进行Object对象深拷贝
 * 对一些特殊数据类型，可能出现问题，要注意
 * @param object
 */
function deepCopy(object) {
    return JSON.parse(JSON.stringify(object))
}

/**
 * 反序列化
 * @param str
 * @return {any}
 */
function jsonParser(str) {
    if (str === '') {
        return ''
    }
    return JSON.parse(str)
}

/**
 * 对象序列化
 * @param object
 * @return {string}
 */
function stringIfy(object) {
    return JSON.stringify(object)
}

// JSON.stringify对象序列化，解决undefined、函数和NaN 丢失问题
function JSONStringify(option) {
    return JSON.stringify(option, (key, val) => {
        // 处理函数丢失问题
        if (typeof val === 'function') {
            return `${val}`;
        }
        // 处理undefined丢失问题
        if (typeof val === 'undefined') {
            return 'undefined';
        }
        // 处理NaN转为null的情况（注意： 这里如果使用isNaN的话，那么对象也会走进去）
        if (val !== val) {
            return `${val}`
        }
        return val;
    }, 2)
}
// JSON.parse 反序列化
function JSONParse(jsonStr) {
    const retain = ['function', 'undefined', 'NaN']
    return JSON.parse(jsonStr, (key, val) => {
        // eval 可能在eslint中报错，需要加入下行注释
        // eslint-disable-next-line
        if (typeof val === 'string' && retain.some(s => val.indexOf(s) >= 0)) {
            return eval(`(function(){return ${val}})()`);
        }
        return val
    })
}

/**
 * 给定nodeTree集合，将其扁平化，{id: node}
 * 具体来讲就是将树形结构扁平为数组，每条数据添加一个idChain属性，记录从树形顶级节点到该节点的id链
 * @param nodeTree
 * @param pidChain
 * @return {{}}
 */
function flatTree(nodeTree, pidChain = []) {
    let flatNode = {}
    Object.keys(nodeTree).forEach(key => {
        const node = nodeTree[key]
        const tmp = deepCopy(node)
        delete(tmp.children)
        tmp.idChain = [...pidChain, tmp.id]
        flatNode[tmp.id] = tmp
        flatNode = Object.assign(
            flatNode,
            flatTree(node.children, tmp.idChain)
        )
    })
    return flatNode
}

/**
 * 根据list数据生成map数据
 * @param list
 */
function listToMap(list) {
    let map = {}
    for (obj of list) {
        map[obj.id] = obj
    }
    return map
}

/**
 * 根据map数据生成list数据
 * @param map
 */
function mapToList(map) {
    let list = []
    for (key of Object.keys(map)) {
        list.push(map[key])
    }
    return list
}

/**
 * 根据listTree生成mapTree
 * @param listTree
 */
function listTreeToMapTree(listTree) {
    let mapTree = {}
    for (const obj of listTree) {
        obj.children = listTreeToMapTree(obj.children)
        mapTree[obj.id] = obj
    }
    return mapTree
}

/**
 * 根据mapTree生成listTree
 * @param mapTree
 */
function mapTreeToListTree(mapTree) {
    let listTree = []
    for (const key of Object.keys(mapTree)) {
        let obj = mapTree[key]
        obj.children = mapTreeToListTree(obj.children)
        listTree.push(obj)
    }
    return listTree
}

export default {
    getSearchValue,
    deepCopy,
    jsonParser,
    stringIfy,
    JSONStringify,
    JSONParse,
    listToMap,
    mapToList,
    listTreeToMapTree,
    mapTreeToListTree,
    flatTree
}
